第一题

现有的程序代码模拟产生了16个日志对象，并且需要运行16秒才能打印完这些日志，请在程序中增加4个线程去调用parseLog()方法来分头打印这16个日志对象，程序只需要运行4秒即可打印完这些日志对象。

  1. public class Test {  
  3.         public static void main(String[] args){  
  5.             System.out.println("begin:"+(System.currentTimeMillis()/1000));  
  6.             /*模拟处理16行日志，下面的代码产生了16个日志对象，当前代码需要运行16秒才能打印完这些日志。 
  7.             修改程序代码，开四个线程让这16个对象在4秒钟打完。 
  8.             */  
  9.             for(int i=0;i<16;i++){  //这行代码不能改动  
  10.                 final String log = ""+(i+1);   //这行代码不能改动  
  11.                 {  
  12.                         Test.parseLog(log);  
  13.                 }  
  14.             }  
  15.         }  
  17.         //parseLog方法内部的代码不能改动  
  18.         public static void parseLog(String log){  
  19.             System.out.println(log+":"+(System.currentTimeMillis()/1000));  
  21.             try {  
  22.                 Thread.sleep(1000);  
  23.             } catch (InterruptedException e) {  
  24.                 e.printStackTrace();  
  25.             }         
  26.         }     
  27.     }

实现：通过阻塞队列实现线程间的通信

  1. import java.util.concurrent.ArrayBlockingQueue;  
  2. import java.util.concurrent.BlockingQueue;  
  4. //BlockingQueue  
  5. public class Test {  
  7.     public static void main(String[] args){  
  9.         //创建一个空间大小为16的阻塞队列，空间大小可以任意，因为每次打印都要1秒，在此期间，  
  10.         //4个线程足以不断去从队列中取数据，然后打印,即在1秒内打印4条日志信息  
  11.         final BlockingQueue<String> queue = new ArrayBlockingQueue<String>(16);  
  13.         //开启4个线程打印  
  14.         for(int i=0;i<4;i++){  
  15.             new Thread(new Runnable(){  
  16.                 @Override  
  17.                 public void run() {  
  18.                     while(true){  
  19.                         try {  
  20.                             //开始没有数据，阻塞，一旦有其中一个线程就去取数据，即不再阻塞，就开始打印
  21.                             String log = queue.take();    
  22.                             parseLog(log);  
  23.                         } catch (InterruptedException e) {  
  24.                             e.printStackTrace();  
  25.                         }  
  26.                     }  
  27.                 }  
  29.             }).start();  
  30.         }  
  32.         //打印秒数  
  33.         System.out.println("begin:"+(System.currentTimeMillis()/1000));  
  36.         for(int i=0;i<16;i++){  // 这行代码不能改动  
  37.             final String log = ""+(i+1); // 这行代码不能改动  
  38.             {  
  39.                     try {  
  40.                         queue.put(log);  // 向队列中存储数据  
  41.                     } catch (InterruptedException e) {  
  42.                         e.printStackTrace();  
  43.                     }  
  44.                     //Test.parseLog(log);  
  45.             }  
  46.         }  
  47.     }  
  49.     //parseLog方法内部的代码不能改动  
  50.     public static void parseLog(String log){  
  51.         System.out.println(log+":"+(System.currentTimeMillis()/1000));  
  53.         try {  
  54.             Thread.sleep(1000);     // 模拟每条日志打印需要1秒  
  55.         } catch (InterruptedException e) {  
  56.             e.printStackTrace();  
  57.         }         
  58.     }   
  59. }

第二题

现成程序中的Test类中的代码在不断地产生数据，然后交给TestDo.doSome()方法去处理，就好像生产者在不断地产生数据，消费者在不断消费数据。

请将程序改造成有10个线程来消费生成者产生的数据，这些消费者都调用TestDo.doSome()方法去进行处理，故每个消费者都需要一秒才能处理完，程序应保证这些消费者线程依次有序地消费数据，只有上一个消费者消费完后，下一个消费者才能消费数据，下一个消费者是谁都可以，但要保证这些消费者线程拿到的数据是有顺序的。

  1. public class Test {  
  3.         public static void main(String[] args) {  
  5.             System.out.println("begin:"+(System.currentTimeMillis()/1000));  
  6.             for(int i=0;i<10;i++){  //这行不能改动  
  7.                 String input = i+"";  //这行不能改动  
  8.                 String output = TestDo.doSome(input);  
  9.                 System.out.println(Thread.currentThread().getName()+ ":" + output);  
  10.             }  
  11.         }  
  12.     }  
  14.     //不能改动此TestDo类  
  15.     class TestDo {  
  16.         public static String doSome(String input){  
  18.             try {  
  19.                 Thread.sleep(1000);  
  20.             } catch (InterruptedException e) {  
  21.                 e.printStackTrace();  
  22.             }  
  23.             String output = input + ":"+ (System.currentTimeMillis() / 1000);  
  24.             return output;  
  25.         }  
  26.     }

在实现之前先介绍一个阻塞队列：SynchronousQuene，一种阻塞队列，其中每个插入操作必须等待另一个线程的对应移除操作 ，反之亦然。同步队列没有任何内部容量，甚至连一个队列的容量都没有。除非另一个线程试图移除某个元素，否则也不能（使用任何方法）插入元素；也不能迭代队列，因为其中没有元素可用于迭代。

应用：它非常适合于传递性设计，在这种设计中，在一个线程中运行的对象要将某些信息、事件或任务传递给在另一个线程中运行的对象，它就必须与该对象同步。 

  1. import java.util.concurrent.SynchronousQueue;  
  3. /*Semaphore与SynchronousQueue的混合使用。 
  4.     由于Semaphore只有1个许可权，所以谁先拿到谁执行，然后释放，保证依次执行, 
  5.     用锁也行，只要保证一个线程执行即可 
  6.     SynchronousQueue是必须有其他线程取的动作，这样一一对应 
  7. */  
  8. public class Test {  
  10.     public static void main(String[] args) {  
  12.         //定义一个许可权为1的信号灯  
  13.         final Semaphore semaphore = new Semaphore(1);  
  15.         //产生的结果无序  
  16.         final SynchronousQueue<String> queue = new SynchronousQueue<String>();  
  18.         //产生10个线程  
  19.         for(int i=0;i<10;i++){  
  20.             new Thread(new Runnable(){  
  21.                 @Override  
  22.                 public void run() {   
  23.                     try {  
  24.                         semaphore.acquire();    //获取许可  
  25.                         String input = queue.take();    //获取并移除此队列的头  
  26.                         String output = TestDo.doSome(input);  
  27.                         System.out.println(Thread.currentThread().getName()+ ":" + output);  
  28.                         semaphore.release();    //释放许可  
  29.                     } catch (InterruptedException e) {  
  30.                         // TODO Auto-generated catch block  
  31.                         e.printStackTrace();  
  32.                     }     
  33.                 }  
  34.             }).start();  
  35.         }  
  37.         System.out.println("begin:"+(System.currentTimeMillis()/1000));  
  38.         for(int i=0;i<10;i++){  //这行不能改动  
  39.             String input = i+"";  //这行不能改动  
  40.             try {  
  41.                 queue.put(input); //将指定元素添加到此队列  
  42.             } catch (InterruptedException e) {  
  43.                 e.printStackTrace();  
  44.             }  
  45.         }  
  46.     }  
  47. }  
  49. //不能改动此TestDo类  
  50. class TestDo {  
  51.     public static String doSome(String input){  
  53.         try {  
  54.             Thread.sleep(1000);  
  55.         } catch (InterruptedException e) {  
  56.             e.printStackTrace();  
  57.         }  
  58.         String output = input + ":"+ (System.currentTimeMillis() / 1000);  
  59.         return output;  
  60.     }  
  61. }

第三题

现有程序同时启动了4个线程去调用TestDo.doSome(key, value)方法，由于TestDo.doSome(key, value)方法内的代码是先暂停1秒，然后再输出以秒为单位的当前时间值，所以，会打印出4个相同的时间值，如下所示：

  1. 4:4:1258199615
  2. 1:1:1258199615
  3. 3:3:1258199615
  4. 1:2:1258199615

请修改代码，如果有几个线程调用TestDo.doSome(key, value)方法时，传递进去的key相等（equals比较为true），则这几个线程应互斥排队输出结果，即当有两个线程的key都是”1”时，它们中的一个要比另外其他线程晚1秒输出结果，如下所示：

  1. 4:4:1258199615
  2. 1:1:1258199615
  3. 3:3:1258199615
  4. 1:2:1258199616

总之，当每个线程中指定的key相等时，这些相等key的线程应每隔一秒依次输出时间值（要用互斥），如果key不同，则并行执行（相互之间不互斥）。

  1.     //不能改动此Test类      
  2.     public class Test extends Thread{  
  4.         private TestDo testDo;  
  5.         private String key;  
  6.         private String value;  
  8.         public Test(String key,String key2,String value){  
  9.             this.testDo = TestDo.getInstance();  
  10.             /*常量"1"和"1"是同一个对象，下面这行代码就是要用"1"+""的方式产生新的对象， 
  11.             以实现内容没有改变，仍然相等（都还为"1"），但对象却不再是同一个的效果*/  
  12.             this.key = key+key2;   
  13.             this.value = value;  
  14.         }  
  17.         public static void main(String[] args) throws InterruptedException{  
  18.             Test a = new Test("1","","1");  
  19.             Test b = new Test("1","","2");  
  20.             Test c = new Test("3","","3");  
  21.             Test d = new Test("4","","4");  
  22.             System.out.println("begin:"+(System.currentTimeMillis()/1000));  
  23.             a.start();  
  24.             b.start();  
  25.             c.start();  
  26.             d.start();  
  28.         }  
  30.         public void run(){  
  31.             testDo.doSome(key, value);  
  32.         }  
  33.     }  
  35.     class TestDo {  
  37.         private TestDo() {}  
  38.         private static TestDo _instance = new TestDo();   
  39.         public static TestDo getInstance() {  
  40.             return _instance;  
  41.         }  
  43.         public void doSome(Object key, String value) {  
  45.             // 以大括号内的是需要局部同步的代码，不能改动!  
  46.             {  
  47.                 try {  
  48.                     Thread.sleep(1000);  
  49.                     System.out.println(key+":"+value + ":"  
  50.                             + (System.currentTimeMillis() / 1000));  
  51.                 } catch (InterruptedException e) {  
  52.                     e.printStackTrace();  
  53.                 }  
  54.             }  
  55.         }  
  56.     }

对于源代码中关于实现值相同而对象不同的效果进行解释：
对于：

  1.  a = "1"+"";
  2.  b = "1"+"";

编译器自动优化，所以a和b是同一个对象

而对于：key = key+key2; 由于是变量，编译器无法识别，这时a和b把“1”和“”赋值给key和key2时会得到两个不同的对象

思想：将集合中的对象作为同步代码块的锁，即this锁，每次将对象存入集合中的时候，就判断是否原集合中已经存在一个与将要存入集合的对象值相同的对象，即用equals比较，如果有，那么就获取原来的这个对象，把这个对象作为将要存入对象的锁，这样它们持有的就是同一把锁，即可实现互斥，这样就可以实现值相同的对象在不同的时刻打印的效果

代码中出现的问题：在遍历ArrayList集合查找与要存入值相同元素的时候，进行了添加的动作，所以会出现并发修改异常，因此使用并发的CopyOnWriteArrayList

  1. import java.util.ArrayList;  
  2. import java.util.Iterator;  
  3. import java.util.concurrent.CopyOnWriteArrayList;  
  6. //不能改动此Test类      
  7. public class Test extends Thread{  
  9.     private TestDo testDo;  
  10.     private String key;  
  11.     private String value;  
  13.     public Test(String key,String key2,String value){  
  14.         this.testDo = TestDo.getInstance();  
  15.         /*常量"1"和"1"是同一个对象，下面这行代码就是要用"1"+""的方式产生新的对象， 
  16.         以实现内容没有改变，仍然相等（都还为"1"），但对象却不再是同一个的效果*/  
  18.         this.key = key+key2;    //这里是变量，所以不会优化  
  19. /*      a = "1"+""; 
  20.         b = "1"+""   
  21.         编译器自动优化，所以a和b是同一个对象 
  22. */  
  23.         this.value = value;  
  24.     }  
  27.     public static void main(String[] args) throws InterruptedException{  
  28.         Test a = new Test("1","","1");  
  29.         Test b = new Test("1","","2");  
  30.         Test c = new Test("3","","3");  
  31.         Test d = new Test("4","","4");  
  32.         System.out.println("begin:"+(System.currentTimeMillis()/1000));  
  33.         a.start();  
  34.         b.start();  
  35.         c.start();  
  36.         d.start();  
  38.     }  
  40.     public void run(){  
  41.         testDo.doSome(key, value);  
  42.     }  
  43. }  
  45. class TestDo {  
  47.     private TestDo() {}  
  48.     private static TestDo _instance = new TestDo();   
  49.     public static TestDo getInstance() {  
  50.         return _instance;  
  51.     }  
  53.     //private ArrayList keys = new ArrayList();  
  54.     //迭代的时候不能修改数据，所以使用同步的ArrayList  
  55.     private CopyOnWriteArrayList keys = new CopyOnWriteArrayList();  
  56.     public void doSome(Object key, String value) {  
  57.         Object o = key;  
  58.         if(!keys.contains(o)){  //比较是否已经存入了一个相同值的对象  
  59.             keys.add(o);  
  60.         }else{  
  62.             //迭代，找出原集合里和传进来的值相同的对象  
  63.             for(Iterator iter=keys.iterator();iter.hasNext();){  
  64.                 try {  
  65.                     Thread.sleep(20);   // 迭代的时候休息一会，在ArrayList下演示并发修改异常  
  66.                 } catch (InterruptedException e) {  
  67.                     e.printStackTrace();  
  68.                 }  
  69.                 Object oo = iter.next();  
  70.                 if(oo.equals(o)){   //如果两个对象的值相同  
  71.                     //就让原集合中的那个相等值的对象作为锁对象，由于原对象之前做的就是锁
  72.                     //这样两个锁就相同了，就可以实现互斥
  73.                       o = oo;    
  74.                     break;  
  75.                 }  
  76.             }  
  77.         }  
  78.         synchronized(o)  
  79.         // 以大括号内的是需要局部同步的代码，不能改动!  
  80.         {  
  81.             try {  
  82.                 Thread.sleep(1000);  
  83.                 System.out.println(key+":"+value + ":"  
  84.                         + (System.currentTimeMillis() / 1000));  
  85.             } catch (InterruptedException e) {  
  86.                 e.printStackTrace();  
  87.             }  
  88.         }  
  89.     }  
  90. }